Developer CD Series 1996 July: Mac OS SDK/Dev.CD Jul 96 SDK/Dev.CD Jul 96 SDK1.toast/Development Kits (Disc 1)/Apple Game Sprockets/Examples/DroneZone/DZInput.c

C/C++ Source or Header | 1996-05-16 | 7.5 KB | 327 lines | [TEXT/CWIE]

/*
 *    File:        DZInput.c
 *    Author:        Dan Venolia
 *
 *    Contents:    Handles input devices.
 *
 *    Copyright © 1996 Apple Computer, Inc.
 */

#include <TextUtils.h>

#include "InputSprocket.h"
#include "InputSprocketDriver.h"  //• TEMPORARY

#include "DZGame.h"
#include "DZInput.h"
#include "DZResource.h"

#define USE_MOUSE_AND_KEYBOARD 1

enum {
    kDeviceList_COUNT        = 100
};

enum {
    kElement_Fire,
    kElement_Pause,
    kElement_ShowHUD,
    kElement_ShowFPS,
    kElement_LIST_COUNT,  // only elements above this line go onto the event list
    kElement_Turn = kElement_LIST_COUNT,
    kElement_COUNT
};


static Boolean                    gInputActive = false;
static ISpElementListReference    gInputEventList = NULL;
static ISpElementReference        gInputElement[kElement_COUNT] = {NULL, NULL, NULL, NULL, NULL};


/* =============================================================================
 *        Input_Init (external)
 *
 *    Initializes the Input stuff.
 * ========================================================================== */
void Input_Init(
    void)
{
    UInt32                        count;
    ISpDeviceReference            deviceList[kDeviceList_COUNT];

    ISpNeed                        needs[kElement_COUNT] =
    {
        { "\p", kIconSuiteID_Fire,        kISpElementKind_Button,        kISpElementLabel_Fire,    0    },
        { "\p", kIconSuiteID_Pause,     kISpElementKind_Button,        kISpElementLabel_Start,    0    },
        { "\p", kIconSuiteID_ShowHUD,    kISpElementKind_Button,        kISpElementLabel_None,    0    },
        { "\p", kIconSuiteID_ShowFPS,    kISpElementKind_Button,        kISpElementLabel_None,    0    },
        { "\p",    kIconSuiteID_Turn,         kISpElementKind_Movement,    kISpElementLabel_None,    0    },
    };

    // Get the names for the needs
    GetIndString(needs[kElement_Fire].name,        kStrListID_NeedsNames,    kElement_Fire+1);
    GetIndString(needs[kElement_Pause].name,    kStrListID_NeedsNames,    kElement_Pause+1);
    GetIndString(needs[kElement_ShowHUD].name,    kStrListID_NeedsNames,    kElement_ShowHUD+1);
    GetIndString(needs[kElement_ShowFPS].name,    kStrListID_NeedsNames,    kElement_ShowFPS+1);
    GetIndString(needs[kElement_Turn].name,        kStrListID_NeedsNames,    kElement_Turn+1);

    #if USE_MOUSE_AND_KEYBOARD
        // Enable the mouse

        // NOTE: This is not the correct way to handle the list count thing.  We
        // should actually call once with NULL for the device list, malloc a list of
        // that size, and call again.

        ISpDevices_ExtractByClass(
                kISpDeviceClass_Mouse,
                kDeviceList_COUNT,
                &count,
                deviceList);

        if (count > kDeviceList_COUNT)
        {
            count = kDeviceList_COUNT;
        }

        ISpDevices_Activate(
                count,
                deviceList);

        // Enable the keyboard
        ISpDevices_ExtractByClass(
                kISpDeviceClass_Keyboard,
                kDeviceList_COUNT,
                &count,
                deviceList);

        if (count > kDeviceList_COUNT)
        {
            count = kDeviceList_COUNT;
        }

        ISpDevices_Activate(
                count,
                deviceList);
    #endif

    // Set our virtual elements
      ISpElement_NewVirtualFromNeeds(
              kElement_COUNT,
              needs,
              gInputElement,
              0);

    // Autoconfigure our virtual elements based on our needs
    ISpInit(
            kElement_COUNT,
            needs,
            gInputElement,
            ' dz ',
            '????',  // could use this as versioning on the needs
            0,
            0,
            0);

      // Build our list of elements, which we'll poll for events
    ISpElementList_New(
            kElement_LIST_COUNT,
            gInputElement,
            &gInputEventList,
            0);

    //• SHOULD construct our element list by hand -- add the refcons one-by-one

    // Start off suspended (because the game is stopped)
    ISpSuspend();

    #if 1  //• TEMPORARY
    {
        // Initialize the virtual movement element to (mid,mid)
        ISpMovementData data;
        AbsoluteTime time;

        data.xAxis = kISpAxisMiddle;
        data.yAxis = kISpAxisMiddle;
        data.direction = kISpPadIdle;

        time.hi = 0;
        time.lo = 0;

        ISpElement_PushComplexData(gInputElement[kElement_Turn], sizeof(ISpMovementData), &data, &time);
    }
    #endif
}


/* =============================================================================
 *        Input_Exit (external)
 *
 *    Prepares for exit.
 * ========================================================================== */
void Input_Exit(
    void)
{
    if (gInputEventList != NULL)
    {
        ISpElementList_Dispose(gInputEventList);
        gInputEventList = NULL;
    }

     ISpStop();

    ISpElement_DisposeVirtual(kElement_COUNT, gInputElement);
}


/* =============================================================================
 *        Input_Configure (external)
 *
 *    Show the configuration dialog.
 * ========================================================================== */
void Input_Configure(
    void)
{
    #if 0
        //••• THIS IS THE WAY THIS SHOULD READ
         ISpConfigure(NULL);
    #else
        //••• THIS IS A TEMPORARY HACK
        if (gInputActive)
        {
             ISpConfigure(NULL);
        }
        else
        {
            ISpResume();
             ISpConfigure(NULL);
             ISpSuspend();
        }
    #endif
}


/* =============================================================================
 *        Input_GetState (external)
 *
 *    This routine handles the elements that are polled.  It returns in outXTurn
 *    and outYTurn the "turn" controls in the ±1 range.
 * ========================================================================== */
void Input_GetState(
    float*                outXTurn,
    float*                outYTurn)
{
    ISpMovementData        movementData;
    float                xTurn;
    float                yTurn;

    // Get the data
    ISpElement_GetComplexState(
            gInputElement[kElement_Turn],
            sizeof(ISpMovementData),
            &movementData);

    // Turn 'em into ±1 float range
    xTurn = movementData.xAxis;
    xTurn -= kISpAxisMiddle;
    xTurn /= kISpAxisMaximum-kISpAxisMiddle;

    yTurn = movementData.yAxis;
    yTurn -= kISpAxisMiddle;
    yTurn /= kISpAxisMaximum-kISpAxisMiddle;

    // Return the values
    *outXTurn = xTurn;
    *outYTurn = yTurn;
}


/* =============================================================================
 *        Input_GetEvent (external)
 *
 *    This routine handles the elements that are event-based.  It returns an
 *    event code indicating which button has gone down.  Note that we ignore
 *    button-up transitions.  Should be called repeatedly until it return
 *    kInputEvent_None.
 * ========================================================================== */
TInputEvent Input_GetEvent(
    void)
{
    TInputEvent            result = kInputEvent_None;
    ISpElementEvent        event;
    Boolean                gotEvent;

    ISpElementList_GetNextEvent(gInputEventList, sizeof(event), &event, &gotEvent);

    if (gotEvent && event.data != 0)
    {
        #if 0
            //••• RESTORE THIS WHEN WE GET THE REFCON SET
            result = event->refCon;
        #else
            if (event.element == gInputElement[kElement_Fire])
            {
                result = kInputEvent_Fire;
            }
            else if (event.element == gInputElement[kElement_Pause])
            {
                result = kInputEvent_Pause;
            }
            else if (event.element == gInputElement[kElement_ShowHUD])
            {
                result = kInputEvent_ShowHUD;
            }
            else if (event.element == gInputElement[kElement_ShowFPS])
            {
                result = kInputEvent_ShowFPS;
            }
        #endif
    }

    return result;
}


/* =============================================================================
 *        Input_Activate (external)
 *
 *    On deactivation, we suspend InputSprocket.  On activation we resume it and
 *    flush the event queue.  We only allow activation when the game is in "Play"
 *    state.
 * ========================================================================== */
void Input_Activate(
    Boolean                inActivate)
{
    Boolean                doActivate;

    doActivate = inActivate;
    if (doActivate && Game_GetState() != kGameState_Playing)
    {
        doActivate = false;
    }

    if (gInputActive != doActivate)
    {
        gInputActive = doActivate;

         if (gInputActive)
         {
             #if USE_MOUSE_AND_KEYBOARD
                 HideCursor();
             #endif

             ISpResume();
             ISpElementList_Flush(gInputEventList);
         }
         else
         {
             ISpSuspend();

             #if USE_MOUSE_AND_KEYBOARD
                 ShowCursor();
             #endif
         }
    }
}